/*
 * Copyright 2017 ~ 2025 the original author or authors. <wanglsir@gmail.com, 983708408@qq.com>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.wl4g.devops.dguid.baidu;

import org.springframework.util.Assert;

/**
 * Allocate 64 bits for the UID(long)<br>
 * sign (fixed 1bit) -> deltaSecond -> workerId -> sequence(within the same
 * second)
 * 
 * @author yutianbao
 */
public class BitsAllocator {

	/**
	 * Total 64 bits
	 */
	public static final int TOTAL_BITS = 1 << 6;

	/**
	 * Bits for [sign-> second-> workId-> sequence]
	 */
	private int signBits = 1;
	private final int timestampBits;
	private final int workerIdBits;
	private final int sequenceBits;

	/**
	 * Max value for workId & sequence
	 */
	private final long maxDeltaSeconds;
	private final long maxWorkerId;
	private final long maxSequence;

	/**
	 * Shift for timestamp & workerId
	 */
	private final int timestampShift;
	private final int workerIdShift;

	/**
	 * Constructor with timestampBits, workerIdBits, sequenceBits<br>
	 * The highest bit used for sign, so <code>63</code> bits for timestampBits,
	 * workerIdBits, sequenceBits
	 */
	public BitsAllocator(int timestampBits, int workerIdBits, int sequenceBits) {
		// make sure allocated 64 bits
		int allocateTotalBits = signBits + timestampBits + workerIdBits + sequenceBits;
		Assert.isTrue(allocateTotalBits == TOTAL_BITS, "allocate not enough 64 bits");

		// initialize bits
		this.timestampBits = timestampBits;
		this.workerIdBits = workerIdBits;
		this.sequenceBits = sequenceBits;

		// initialize max value
		this.maxDeltaSeconds = ~(-1L << timestampBits);
		this.maxWorkerId = ~(-1L << workerIdBits);
		this.maxSequence = ~(-1L << sequenceBits);

		// initialize shift
		this.timestampShift = workerIdBits + sequenceBits;
		this.workerIdShift = sequenceBits;
	}

	/**
	 * Allocate bits for UID according to delta seconds & workerId &
	 * sequence<br>
	 * <b>Note that: </b>The highest bit will always be 0 for sign
	 * 
	 * @param deltaSeconds
	 * @param workerId
	 * @param sequence
	 * @return
	 */
	public long allocate(long deltaSeconds, long workerId, long sequence) {
		return (deltaSeconds << timestampShift) | (workerId << workerIdShift) | sequence;
	}

	/**
	 * Getters
	 */
	public int getSignBits() {
		return signBits;
	}

	public int getTimestampBits() {
		return timestampBits;
	}

	public int getWorkerIdBits() {
		return workerIdBits;
	}

	public int getSequenceBits() {
		return sequenceBits;
	}

	public long getMaxDeltaSeconds() {
		return maxDeltaSeconds;
	}

	public long getMaxWorkerId() {
		return maxWorkerId;
	}

	public long getMaxSequence() {
		return maxSequence;
	}

	public int getTimestampShift() {
		return timestampShift;
	}

	public int getWorkerIdShift() {
		return workerIdShift;
	}

	@Override
	public String toString() {
		return "BitsAllocator [signBits=" + signBits + ", timestampBits=" + timestampBits + ", workerIdBits=" + workerIdBits
				+ ", sequenceBits=" + sequenceBits + ", maxDeltaSeconds=" + maxDeltaSeconds + ", maxWorkerId=" + maxWorkerId
				+ ", maxSequence=" + maxSequence + ", timestampShift=" + timestampShift + ", workerIdShift=" + workerIdShift
				+ "]";
	}

}